package api

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
	"strconv"
	"strings"
	"time"
	"yunwei/go_api/application/model"
	"yunwei/go_api/application/services"
)

// 分页查询任务列表
func GetTaskList(ctx *gin.Context) {
	// 获取当前页码
	page, err := strconv.Atoi(ctx.Query("page"))
	if err != nil || page <= 0 {
		page = 1
	}

	// 获取每页显示的数量
	limit, err := strconv.Atoi(ctx.Query("limit"))
	if err != nil || limit <= 0 {
		limit = 10
	}
	fmt.Println(page, limit)
	// 过滤条件
	var filters []interface{}
	// 状态
	// -1-删除 0-停用 1-启用 2-待审核 3-审核不通过
	statusIn := []int{0, 1, 2, 3}
	filters = append(filters, "status IN (?)", statusIn)

	taskName := strings.TrimSpace(ctx.Query("task_name"))
	if taskName != "" {
		filters = append(filters, "task_name LIKE ?", "%"+taskName+"%")
	}

	groupID, err := strconv.Atoi(ctx.Query("group_id"))
	if groupID > 0 {
		filters = append(filters, "group_id = ?", groupID)
	}
	tasks, count := model.TaskGetList(page, limit, filters...)
	// 响应数据
	list := make([]map[string]interface{}, len(tasks))
	// 遍历分页数据，组装map切片
	for index, task := range tasks {
		row := make(map[string]interface{})
		// id task_name description next_time pre_time execute_times
		row["id"] = task.Id
		// 分组名-任务名
		taskGroup := taskGroupLists()
		fmt.Println("taskGroup:::", taskGroup)
		groupName := "默认分组"
		if name, ok := taskGroup[task.GroupId]; ok {
			groupName = name
		}
		// 状态
		// -1-删除 0-停用 1-启用 2-待审核 3-审核不通过
		row["task_name"] = groupName + "-" + task.TaskName
		row["description"] = task.Description
		row["execute_times"] = task.ExecuteTimes
		list[index] = row
	}

	ctx.JSON(200, gin.H{
		"code":  200,
		"count": count,
		"data":  list,
	})
}

// 获取任务分组信息
func taskGroupLists() map[int]string {
	groupFilters := make([]interface{}, 0)
	// 1-正常 0-删除
	groupResult, n := model.GroupGetList(1, 10, groupFilters...)
	// 组装返回数据
	res := make(map[int]string, n)
	for _, gv := range groupResult {
		res[gv.Id] = gv.GroupName
	}
	return res
}

// 启动任务，支持批量操作
func Start(ctx *gin.Context) {
	ids := ctx.PostForm("ids")
	print("ids:::", ids)
	idArr := strings.Split(ids, ",")
	fmt.Println("idArr:::", len(idArr), idArr)
	if ids == "" {
		ctx.JSON(200, gin.H{
			"MSG_ERR": "请选择要操作的任务！",
		})
		return
	}
	// 遍历用户选的id
	for _, v := range idArr {
		id, _ := strconv.Atoi(v)
		if id < 1 {
			continue
		}
		if task, err := model.TaskGetById(id); err == nil {
			// 启动任务
			job, err := services.NewJobFromTask(task)
			if err == nil {
				// 将当前job添加到切片中
				services.AddJob(task.CronSpec, *job)
				// 修改任务的状态为启动
				task.Status = 1
				// 更新入库
				err := task.Update("status")
				if err != nil {
					fmt.Println(err)
				}
			}
		}
	}
	// 返回ajax提示信息
	ctx.JSON(200, gin.H{
		"message": "启动任务成功",
		"status":  0,
	})
}

// 停止任务，支持批量操作
func Pause(ctx *gin.Context) {
	ids := ctx.PostForm("ids")
	print("ids:::", ids)
	idArr := strings.Split(ids, ",")
	fmt.Println("idArr:::", len(idArr), idArr)
	if ids == "" {
		ctx.JSON(200, gin.H{
			"MSG_ERR": "请选择要操作的任务！",
		})
		return
	}
	// 遍历用户选的id
	for _, v := range idArr {
		id, _ := strconv.Atoi(v)
		if id < 1 {
			continue
		}
		services.RemoveJob(id)
		if task, err := model.TaskGetById(id); err == nil {
			// 修改任务的状态为暂停
			task.Status = 0
			// 更新入库
			err := task.Update("status")
			fmt.Println("修改任务后：", task)
			if err != nil {
				fmt.Println("修改任务的状态失败:::", err)
			}
		}
	}
	// 返回ajax提示信息
	ctx.JSON(200, gin.H{
		"message": "暂停成功",
		"status":  0,
	})
}

// 任务详情
// /task/detail

func Detail(c *gin.Context) {
	id, _ := strconv.Atoi(c.Query("id"))

	// 根据id查task
	task, err := model.TaskGetById(id)
	if err != nil {
		return
	}

	TextStatus := []string{
		"暂停",
		"运行中",
		"待审核",
		"审核失败",
	}

	groupName := "默认分组"
	group, err := model.TaskGroupGetById(task.GroupId)
	if err == nil {
		groupName = group.GroupName
	}

	// 服务器名
	serverName := "默认服务器"
	if task.ServerId == 0 {
		serverName = "本地服务器"
	} else if task.ServerId > 0 {
		var host = model.Host{}
		err := host.GetOneById(uint(task.ServerId))
		if err == nil {
			serverName = host.Name
		}
	}
	// 通知人
	var adminInfo []*model.User
	if task.NotifyUserIds != "0" && task.NotifyUserIds != "" {
		adminInfo = services.AllUserInfo(task.NotifyUserIds)
	}

	createTime := time.Unix(task.CreateTime, 0).Format("2006-01-02 15:04:05")
	// CreateName
	createName := "默认创建人"
	// UpdateTime  UpdateName
	updateTime := time.Unix(task.UpdateTime, 0).Format("2006-01-02 15:04:05")
	updateName := "默认修改人"

	c.JSON(http.StatusOK, gin.H{
		"Task":       task,
		"TextStatus": TextStatus[task.Status],
		"GroupName":  groupName,
		"ServerName": serverName,
		"AdminInfo":  adminInfo,
		"CreateTime": createTime,
		"CreateName": createName,
		"UpdateTime": updateTime,
		"UpdateName": updateName,
	})
}

// 测试任务
func Run(ctx *gin.Context) {
	id, _ := strconv.Atoi(ctx.Query("id"))
	// 根据id查task
	task, err := model.TaskGetById(id)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{
			"err": "查不到该任务，无法运行",
		})
		return
	}
	job, err := services.NewJobFromTask(task)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{
			"err": "任务创建失败，无法运行",
		})
		return
	}
	if job != nil {
		// 运行一次，不加入运行时切片
		timeout := time.Duration(10 * time.Second)
		cmdOut, cmdErr, err, _ := job.RunFunc(timeout)

		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{
				"msg": "任务运行失败！",
				"err": cmdErr,
			})
		} else {
			ctx.JSON(http.StatusOK, gin.H{
				"msg":    "任务测试成功！",
				"cmdOut": cmdOut,
			})
		}
	}
}
